"use strict";
/*!-----------------------------------------------------------------------------
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Version: 0.34.1(547870b6881302c5b4ff32173c16d06009e3588f)
 * Released under the MIT license
 * https://github.com/microsoft/monaco-editor/blob/main/LICENSE.txt
 *-----------------------------------------------------------------------------*/
define("vs/basic-languages/python/python", ["require"], require => {
	var moduleExports = (() => {
		var __create = Object.create;
		var __defProp = Object.defineProperty;
		var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
		var __getOwnPropNames = Object.getOwnPropertyNames;
		var __getProtoOf = Object.getPrototypeOf;
		var __hasOwnProp = Object.prototype.hasOwnProperty;
		var __require = /* @__PURE__ */ (x =>
			typeof require !== "undefined"
				? require
				: typeof Proxy !== "undefined"
				? new Proxy(x, {
						get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
				  })
				: x)(function (x) {
			if (typeof require !== "undefined") return require.apply(this, arguments);
			throw new Error('Dynamic require of "' + x + '" is not supported');
		});
		var __commonJS = (cb, mod) =>
			function __require2() {
				return (
					mod ||
						(0, cb[__getOwnPropNames(cb)[0]])(
							(mod = { exports: {} }).exports,
							mod
						),
					mod.exports
				);
			};
		var __export = (target, all) => {
			for (var name in all)
				__defProp(target, name, { get: all[name], enumerable: true });
		};
		var __copyProps = (to, from, except, desc) => {
			if ((from && typeof from === "object") || typeof from === "function") {
				for (let key of __getOwnPropNames(from))
					if (!__hasOwnProp.call(to, key) && key !== except)
						__defProp(to, key, {
							get: () => from[key],
							enumerable:
								!(desc = __getOwnPropDesc(from, key)) || desc.enumerable
						});
			}
			return to;
		};
		var __reExport = (target, mod, secondTarget) => (
			__copyProps(target, mod, "default"),
			secondTarget && __copyProps(secondTarget, mod, "default")
		);
		var __toESM = (mod, isNodeMode, target) => (
			(target = mod != null ? __create(__getProtoOf(mod)) : {}),
			__copyProps(
				isNodeMode || !mod || !mod.__esModule
					? __defProp(target, "default", { value: mod, enumerable: true })
					: target,
				mod
			)
		);
		var __toCommonJS = mod =>
			__copyProps(__defProp({}, "__esModule", { value: true }), mod);

		// src/fillers/monaco-editor-core-amd.ts
		var require_monaco_editor_core_amd = __commonJS({
			"src/fillers/monaco-editor-core-amd.ts"(exports, module) {
				var api = __toESM(__require("vs/editor/editor.api"));
				module.exports = api;
			}
		});

		// src/basic-languages/python/python.ts
		var python_exports = {};
		__export(python_exports, {
			conf: () => conf,
			language: () => language
		});

		// src/fillers/monaco-editor-core.ts
		var monaco_editor_core_exports = {};
		__reExport(
			monaco_editor_core_exports,
			__toESM(require_monaco_editor_core_amd())
		);

		// src/basic-languages/python/python.ts
		var conf = {
			comments: {
				lineComment: "#",
				blockComment: ["'''", "'''"]
			},
			brackets: [
				["{", "}"],
				["[", "]"],
				["(", ")"]
			],
			autoClosingPairs: [
				{ open: "{", close: "}" },
				{ open: "[", close: "]" },
				{ open: "(", close: ")" },
				{ open: '"', close: '"', notIn: ["string"] },
				{ open: "'", close: "'", notIn: ["string", "comment"] }
			],
			surroundingPairs: [
				{ open: "{", close: "}" },
				{ open: "[", close: "]" },
				{ open: "(", close: ")" },
				{ open: '"', close: '"' },
				{ open: "'", close: "'" }
			],
			onEnterRules: [
				{
					beforeText: new RegExp(
						"^\\s*(?:def|class|for|if|elif|else|while|try|with|finally|except|async|match|case).*?:\\s*$"
					),
					action: {
						indentAction:
							monaco_editor_core_exports.languages.IndentAction.Indent
					}
				}
			],
			folding: {
				offSide: true,
				markers: {
					start: new RegExp("^\\s*#region\\b"),
					end: new RegExp("^\\s*#endregion\\b")
				}
			}
		};
		var language = {
			defaultToken: "",
			tokenPostfix: ".python",
			keywords: [
				"False",
				"None",
				"True",
				"_",
				"and",
				"as",
				"assert",
				"async",
				"await",
				"break",
				"case",
				"class",
				"continue",
				"def",
				"del",
				"elif",
				"else",
				"except",
				"exec",
				"finally",
				"for",
				"from",
				"global",
				"if",
				"import",
				"in",
				"is",
				"lambda",
				"match",
				"nonlocal",
				"not",
				"or",
				"pass",
				"print",
				"raise",
				"return",
				"try",
				"while",
				"with",
				"yield",
				"int",
				"float",
				"long",
				"complex",
				"hex",
				"abs",
				"all",
				"any",
				"apply",
				"basestring",
				"bin",
				"bool",
				"buffer",
				"bytearray",
				"callable",
				"chr",
				"classmethod",
				"cmp",
				"coerce",
				"compile",
				"complex",
				"delattr",
				"dict",
				"dir",
				"divmod",
				"enumerate",
				"eval",
				"execfile",
				"file",
				"filter",
				"format",
				"frozenset",
				"getattr",
				"globals",
				"hasattr",
				"hash",
				"help",
				"id",
				"input",
				"intern",
				"isinstance",
				"issubclass",
				"iter",
				"len",
				"locals",
				"list",
				"map",
				"max",
				"memoryview",
				"min",
				"next",
				"object",
				"oct",
				"open",
				"ord",
				"pow",
				"print",
				"property",
				"reversed",
				"range",
				"raw_input",
				"reduce",
				"reload",
				"repr",
				"reversed",
				"round",
				"self",
				"set",
				"setattr",
				"slice",
				"sorted",
				"staticmethod",
				"str",
				"sum",
				"super",
				"tuple",
				"type",
				"unichr",
				"unicode",
				"vars",
				"xrange",
				"zip",
				"__dict__",
				"__methods__",
				"__members__",
				"__class__",
				"__bases__",
				"__name__",
				"__mro__",
				"__subclasses__",
				"__init__",
				"__import__"
			],
			brackets: [
				{ open: "{", close: "}", token: "delimiter.curly" },
				{ open: "[", close: "]", token: "delimiter.bracket" },
				{ open: "(", close: ")", token: "delimiter.parenthesis" }
			],
			tokenizer: {
				root: [
					{ include: "@whitespace" },
					{ include: "@numbers" },
					{ include: "@strings" },
					[/[,:;]/, "delimiter"],
					[/[{}\[\]()]/, "@brackets"],
					[/@[a-zA-Z_]\w*/, "tag"],
					[
						/[a-zA-Z_]\w*/,
						{
							cases: {
								"@keywords": "keyword",
								"@default": "identifier"
							}
						}
					]
				],
				whitespace: [
					[/\s+/, "white"],
					[/(^#.*$)/, "comment"],
					[/'''/, "string", "@endDocString"],
					[/"""/, "string", "@endDblDocString"]
				],
				endDocString: [
					[/[^']+/, "string"],
					[/\\'/, "string"],
					[/'''/, "string", "@popall"],
					[/'/, "string"]
				],
				endDblDocString: [
					[/[^"]+/, "string"],
					[/\\"/, "string"],
					[/"""/, "string", "@popall"],
					[/"/, "string"]
				],
				numbers: [
					[/-?0x([abcdef]|[ABCDEF]|\d)+[lL]?/, "number.hex"],
					[/-?(\d*\.)?\d+([eE][+\-]?\d+)?[jJ]?[lL]?/, "number"]
				],
				strings: [
					[/'$/, "string.escape", "@popall"],
					[/'/, "string.escape", "@stringBody"],
					[/"$/, "string.escape", "@popall"],
					[/"/, "string.escape", "@dblStringBody"]
				],
				stringBody: [
					[/[^\\']+$/, "string", "@popall"],
					[/[^\\']+/, "string"],
					[/\\./, "string"],
					[/'/, "string.escape", "@popall"],
					[/\\$/, "string"]
				],
				dblStringBody: [
					[/[^\\"]+$/, "string", "@popall"],
					[/[^\\"]+/, "string"],
					[/\\./, "string"],
					[/"/, "string.escape", "@popall"],
					[/\\$/, "string"]
				]
			}
		};
		return __toCommonJS(python_exports);
	})();
	return moduleExports;
});
